package utils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;


public class ListUtil {
    //去重
    public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
        Map<Object,Boolean> seen = new ConcurrentHashMap<>();
        //putIfAbsent方法添加键值对，如果map集合中没有该key对应的值，则直接添加，并返回null，如果已经存在对应的值，则依旧为原来的值。
        //如果返回null表示添加数据成功(不重复)，不重复(null==null :TRUE)
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }

    //obj转集合
    public static <T> List<T> castList(Object obj, Class<T> clazz)
    {
        List<T> result = new ArrayList<T>();
        if(obj instanceof List<?>)
        {
            for (Object o : (List<?>) obj)
            {
                result.add(clazz.cast(o));
            }
            return result;
        }
        return null;
    }

    //list<Object> 转 List<String>
    public static List<String> objToStrList(List<Object> objs){
        List<String> strList = new ArrayList<>();
        for(Object a:objs){
            String str = String.valueOf(a);
            strList.add(str);
        }
        return strList;
    }

    /**
     * ListMap根据map中的一个列做分类形成分组
     * @param list 需要形成树状图的listmap
     * @param key 需要做分类的map的key
     * @return 树状map
     */
    public static Map<String, Object> listMapClassification(List<Map<String, Object>> list, String key) {
        //创建一个空的新map
        Map<String, Object> newMap = new HashMap<>();
        //循环listmap
        for (int s = 0; s<list.size(); s++){
            //创建一个暂存数据的list
            List<Map<String, Object>> mapList = new ArrayList<>();
            //取出当前list循环下的Map
            Map<String, Object> objectMap = list.get(s);
            //取出map中按key分类好类的值列表
            //第一次循环因为没有插入过值，所以会为空
            Object get = newMap.get((String) objectMap.get(key));
            System.out.println("输出4"+ get);
            //判断分好类的当前类的名字下的值是否为空
            if(get!=null){
                //不为空就将泛型转为list
                mapList=(List<Map<String, Object>>) get;
            }
            //将当前循环的下的那个map插入，分好类的list中
            mapList.add(objectMap);
            //将当前循环插入好的list，重新给分类赋值
            newMap.put((String) objectMap.get(key),mapList);
        }
        return newMap;
    }
    /**
     * ListMapToListString
     */
    public static List<String> ListMapToListString(List<Map> list, String key) {
        //创建一个空的listString
        List<String> newList = new ArrayList<>();
        //循环listmap
        for (int s = 0; s<list.size(); s++){
            //创建一个暂存数据的list
//            List<Map<String, Object>> mapList = new ArrayList<>();
            //取出当前list循环下的Map
            Map objectMap = list.get(s);
            Object str = objectMap.get(key);
            //将当前循环插入好的list，重新给分类赋值
            newList.add(str.toString());
        }
        return newList;
    }
}
